// Date:   Sat Aug 23 12:23:28 PM 2025
// Mail:   lunar_ubuntu@qq.com
// Author: https://github.com/xiaoqixian

#pragma once
#include <yaml-cpp/yaml.h>
// #include <cassert>
// #include <cstddef>
// #include <string>
// #include <variant>
// #include <fstream>
// #include "json.hpp"
// #include <stdexcept>

using Config = YAML::Node;

// inline bool ends_with(const std::string &str, const std::string &suffix) {
//     return str.size() >= suffix.size() &&
//            str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
// }
//
// class Config {
// public:
//   enum class FileType {
//     JSON,
//     YAML
//   };
//
//   Config(std::string const& file) {
//     if (ends_with(file, ".json")) {
//       type_ = FileType::JSON;
//       std::ifstream ifs(file);
//       if (!ifs.is_open()) throw std::runtime_error("Cannot open file: " + file);
//       nlohmann::json j;
//       ifs >> j;
//       data_ = j;
//     } else if (ends_with(file, ".yaml") || ends_with(file, ".yml")) {
//       type_ = FileType::YAML;
//       YAML::Node node = YAML::LoadFile(file);
//       data_ = node;
//     } else {
//       throw std::runtime_error("Unsupported file type: " + file);
//     }
//   }
//
//   friend Config config_get(Config const& config, std::string const& key) {
//     switch (config.type_) {
//       case FileType::JSON: {
//         const auto& j = std::get<nlohmann::json>(config.data_);
//         if (!j.contains(key)) throw std::runtime_error("Key not found: " + key);
//         return Config(j[key]);
//       }
//       case FileType::YAML: {
//         const auto& y = std::get<YAML::Node>(config.data_);
//         if (!y[key]) throw std::runtime_error("Key not found: " + key);
//         return Config(y[key]);
//       }
//       default:
//         throw std::runtime_error("Unknown config type");
//     }
//   }
//
//   Config operator[](std::string const& key) const {
//     return config_get(*this, key);
//   }
//
//   Config operator[](const int idx) {
//     switch (type_) {
//       case FileType::YAML: {
//         auto& y = std::get<YAML::Node>(data_);
//         assert(y.IsSequence());
//         return Config(y[idx]);
//       }
//       default:
//         throw std::runtime_error("unsupported operation");
//     }
//   }
//
//   template <typename T>
//   T as() const {
//     if constexpr (std::is_same_v<T, std::vector<Config>>) {
//       std::vector<Config> res;
//       switch (type_) {
//         case FileType::JSON: {
//           auto const& node = std::get<nlohmann::json>(data_);
//           res.reserve(node.size());
//           for (auto const& item: node) {
//             res.emplace_back(Config(item));
//           }
//           break;
//         }
//         case FileType::YAML: {
//           auto const& node = std::get<YAML::Node>(data_);
//           res.reserve(node.size());
//           for (auto const& item: node) {
//             res.emplace_back(Config(item));
//           }
//           break;
//         }
//       }
//       return res;
//     } else {
//       switch (type_) {
//         case FileType::JSON:
//           return std::get<nlohmann::json>(data_).get<T>();
//         case FileType::YAML: {
//           const auto& node = std::get<YAML::Node>(data_);
//           return node.as<T>();
//         }
//         default:
//           throw std::runtime_error("Unknown config type");
//       }
//     }
//   }
//
//   std::size_t size() const {
//     switch (type_) {
//       case FileType::JSON:
//         return std::get<nlohmann::json>(data_).size();
//       case FileType::YAML:
//         return std::get<YAML::Node>(data_).size();
//     }
//   }
//
// private:
//   Config(nlohmann::json const& j) : type_(FileType::JSON), data_(j) {}
//   Config(YAML::Node const& n) : type_(FileType::YAML), data_(n) {}
//
// private:
//   FileType type_;
//   std::variant<nlohmann::json, YAML::Node> data_;
// };
